home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / CodeWarrior Lite / Metrowerks C⁄C++ Lite / Headers / Universal Headers 2.0.1f / Drag.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-22  |  16.3 KB  |  419 lines  |  [TEXT/MMCC]
  1. /*
  2.      File:        Drag.h
  3.  
  4.      Contains:    Drag and Drop Interfaces.
  5.  
  6.      Version:    Technology:    Macintosh Drag and Drop 1.1
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. */
  19.  
  20. #ifndef __DRAG__
  21. #define __DRAG__
  22.  
  23.  
  24. #ifndef __APPLEEVENTS__
  25. #include <AppleEvents.h>
  26. #endif
  27. /*    #include <Errors.h>                                            */
  28. /*        #include <ConditionalMacros.h>                            */
  29. /*    #include <Types.h>                                            */
  30. /*    #include <Memory.h>                                            */
  31. /*        #include <MixedMode.h>                                    */
  32. /*    #include <OSUtils.h>                                        */
  33. /*    #include <Events.h>                                            */
  34. /*        #include <Quickdraw.h>                                    */
  35. /*            #include <QuickdrawText.h>                            */
  36. /*    #include <EPPC.h>                                            */
  37. /*        #include <AppleTalk.h>                                    */
  38. /*        #include <Files.h>                                        */
  39. /*        #include <PPCToolbox.h>                                    */
  40. /*        #include <Processes.h>                                    */
  41. /*    #include <Notification.h>                                    */
  42.  
  43. #ifndef __TEXTEDIT__
  44. #include <TextEdit.h>
  45. #endif
  46.  
  47. #ifdef __cplusplus
  48. extern "C" {
  49. #endif
  50.  
  51. #if PRAGMA_ALIGN_SUPPORTED
  52. #pragma options align=mac68k
  53. #endif
  54.  
  55. #if PRAGMA_IMPORT_SUPPORTED
  56. #pragma import on
  57. #endif
  58.  
  59.  
  60. enum {
  61. /* Flavor Flags */
  62.     flavorSenderOnly            = 0x00000001L,                    /* flavor is available to sender only */
  63.     flavorSenderTranslated        = 0x00000002L,                    /* flavor is translated by sender */
  64.     flavorNotSaved                = 0x00000004L,                    /* flavor should not be saved */
  65.     flavorSystemTranslated        = 0x00000100L                    /* flavor is translated by system */
  66. };
  67.  
  68. typedef unsigned long FlavorFlags;
  69.  
  70.  
  71. enum {
  72. /* Drag Attributes */
  73.     dragHasLeftSenderWindow        = 0x00000001L,                    /* drag has left the source window since TrackDrag */
  74.     dragInsideSenderApplication    = 0x00000002L,                    /* drag is occurring within the sender application */
  75.     dragInsideSenderWindow        = 0x00000004L                    /* drag is occurring within the sender window */
  76. };
  77.  
  78. typedef unsigned long DragAttributes;
  79.  
  80.  
  81. enum {
  82. /* Special Flavor Types */
  83.     flavorTypeHFS                = 'hfs ',                        /* flavor type for HFS data */
  84.     flavorTypePromiseHFS        = 'phfs',                        /* flavor type for promised HFS data */
  85.     flavorTypeDirectory            = 'diry'
  86. };
  87.  
  88. enum {
  89. /* Drag Tracking Handler Messages */
  90.     dragTrackingEnterHandler    = 1,                            /* drag has entered handler */
  91.     dragTrackingEnterWindow        = 2,                            /* drag has entered window */
  92.     dragTrackingInWindow        = 3,                            /* drag is moving within window */
  93.     dragTrackingLeaveWindow        = 4,                            /* drag has exited window */
  94.     dragTrackingLeaveHandler    = 5                                /* drag has exited handler */
  95. };
  96.  
  97. typedef short DragTrackingMessage;
  98.  
  99.  
  100. enum {
  101. /* Drag Drawing Procedure Messages */
  102.     dragRegionBegin                = 1,                            /* initialize drawing */
  103.     dragRegionDraw                = 2,                            /* draw drag feedback */
  104.     dragRegionHide                = 3,                            /* hide drag feedback */
  105.     dragRegionIdle                = 4,                            /* drag feedback idle time */
  106.     dragRegionEnd                = 5                                /* end of drawing */
  107. };
  108.  
  109. typedef short DragRegionMessage;
  110.  
  111.  
  112. enum {
  113. /* Zoom Acceleration */
  114.     zoomNoAcceleration            = 0,                            /* use linear interpolation */
  115.     zoomAccelerate                = 1,                            /* ramp up step size */
  116.     zoomDecelerate                = 2                                /* ramp down step size */
  117. };
  118.  
  119. typedef short ZoomAcceleration;
  120.  
  121. /* Drag Manager Data Types */
  122. typedef unsigned long DragReference;
  123.  
  124. typedef unsigned long ItemReference;
  125.  
  126. typedef ResType FlavorType;
  127.  
  128. /* HFS Flavors */
  129. struct HFSFlavor {
  130.     OSType                            fileType;                    /* file type */
  131.     OSType                            fileCreator;                /* file creator */
  132.     unsigned short                    fdFlags;                    /* Finder flags */
  133.     FSSpec                            fileSpec;                    /* file system specification */
  134. };
  135. typedef struct HFSFlavor HFSFlavor;
  136.  
  137. struct PromiseHFSFlavor {
  138.     OSType                            fileType;                    /* file type */
  139.     OSType                            fileCreator;                /* file creator */
  140.     unsigned short                    fdFlags;                    /* Finder flags */
  141.     FlavorType                        promisedFlavor;                /* promised flavor containing an FSSpec */
  142. };
  143. typedef struct PromiseHFSFlavor PromiseHFSFlavor;
  144.  
  145. /* Application-Defined Drag Handler Routines */
  146. typedef pascal OSErr (*DragTrackingHandlerProcPtr)(DragTrackingMessage message, WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  147.  
  148. #if GENERATINGCFM
  149. typedef UniversalProcPtr DragTrackingHandlerUPP;
  150. #else
  151. typedef DragTrackingHandlerProcPtr DragTrackingHandlerUPP;
  152. #endif
  153.  
  154. enum {
  155.     uppDragTrackingHandlerProcInfo = kPascalStackBased
  156.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  157.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragTrackingMessage)))
  158.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(WindowPtr)))
  159.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  160.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  161. };
  162.  
  163. #if GENERATINGCFM
  164. #define NewDragTrackingHandlerProc(userRoutine)        \
  165.         (DragTrackingHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, GetCurrentArchitecture())
  166. #else
  167. #define NewDragTrackingHandlerProc(userRoutine)        \
  168.         ((DragTrackingHandlerUPP) (userRoutine))
  169. #endif
  170.  
  171. #if GENERATINGCFM
  172. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        \
  173.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragTrackingHandlerProcInfo, (message), (theWindow), (handlerRefCon), (theDragRef))
  174. #else
  175. #define CallDragTrackingHandlerProc(userRoutine, message, theWindow, handlerRefCon, theDragRef)        \
  176.         (*(userRoutine))((message), (theWindow), (handlerRefCon), (theDragRef))
  177. #endif
  178.  
  179. typedef DragTrackingHandlerUPP DragTrackingHandler;
  180.  
  181. typedef pascal OSErr (*DragReceiveHandlerProcPtr)(WindowPtr theWindow, void *handlerRefCon, DragReference theDragRef);
  182.  
  183. #if GENERATINGCFM
  184. typedef UniversalProcPtr DragReceiveHandlerUPP;
  185. #else
  186. typedef DragReceiveHandlerProcPtr DragReceiveHandlerUPP;
  187. #endif
  188.  
  189. enum {
  190.     uppDragReceiveHandlerProcInfo = kPascalStackBased
  191.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  192.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(WindowPtr)))
  193.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  194.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(DragReference)))
  195. };
  196.  
  197. #if GENERATINGCFM
  198. #define NewDragReceiveHandlerProc(userRoutine)        \
  199.         (DragReceiveHandlerUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, GetCurrentArchitecture())
  200. #else
  201. #define NewDragReceiveHandlerProc(userRoutine)        \
  202.         ((DragReceiveHandlerUPP) (userRoutine))
  203. #endif
  204.  
  205. #if GENERATINGCFM
  206. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        \
  207.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragReceiveHandlerProcInfo, (theWindow), (handlerRefCon), (theDragRef))
  208. #else
  209. #define CallDragReceiveHandlerProc(userRoutine, theWindow, handlerRefCon, theDragRef)        \
  210.         (*(userRoutine))((theWindow), (handlerRefCon), (theDragRef))
  211. #endif
  212.  
  213. typedef DragReceiveHandlerUPP DragReceiveHandler;
  214.  
  215. /* Application-Defined Routines */
  216. typedef pascal OSErr (*DragSendDataProcPtr)(FlavorType theType, void *dragSendRefCon, ItemReference theItemRef, DragReference theDragRef);
  217.  
  218. #if GENERATINGCFM
  219. typedef UniversalProcPtr DragSendDataUPP;
  220. #else
  221. typedef DragSendDataProcPtr DragSendDataUPP;
  222. #endif
  223.  
  224. enum {
  225.     uppDragSendDataProcInfo = kPascalStackBased
  226.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  227.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(FlavorType)))
  228.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void*)))
  229.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ItemReference)))
  230.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  231. };
  232.  
  233. #if GENERATINGCFM
  234. #define NewDragSendDataProc(userRoutine)        \
  235.         (DragSendDataUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragSendDataProcInfo, GetCurrentArchitecture())
  236. #else
  237. #define NewDragSendDataProc(userRoutine)        \
  238.         ((DragSendDataUPP) (userRoutine))
  239. #endif
  240.  
  241. #if GENERATINGCFM
  242. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        \
  243.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragSendDataProcInfo, (theType), (dragSendRefCon), (theItemRef), (theDragRef))
  244. #else
  245. #define CallDragSendDataProc(userRoutine, theType, dragSendRefCon, theItemRef, theDragRef)        \
  246.         (*(userRoutine))((theType), (dragSendRefCon), (theItemRef), (theDragRef))
  247. #endif
  248.  
  249. typedef DragSendDataUPP DragSendDataProc;
  250.  
  251. typedef pascal OSErr (*DragInputProcPtr)(Point *mouse, short *modifiers, void *dragInputRefCon, DragReference theDragRef);
  252.  
  253. #if GENERATINGCFM
  254. typedef UniversalProcPtr DragInputUPP;
  255. #else
  256. typedef DragInputProcPtr DragInputUPP;
  257. #endif
  258.  
  259. enum {
  260.     uppDragInputProcInfo = kPascalStackBased
  261.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  262.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Point*)))
  263.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(short*)))
  264.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void*)))
  265.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(DragReference)))
  266. };
  267.  
  268. #if GENERATINGCFM
  269. #define NewDragInputProc(userRoutine)        \
  270.         (DragInputUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragInputProcInfo, GetCurrentArchitecture())
  271. #else
  272. #define NewDragInputProc(userRoutine)        \
  273.         ((DragInputUPP) (userRoutine))
  274. #endif
  275.  
  276. #if GENERATINGCFM
  277. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        \
  278.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragInputProcInfo, (mouse), (modifiers), (dragInputRefCon), (theDragRef))
  279. #else
  280. #define CallDragInputProc(userRoutine, mouse, modifiers, dragInputRefCon, theDragRef)        \
  281.         (*(userRoutine))((mouse), (modifiers), (dragInputRefCon), (theDragRef))
  282. #endif
  283.  
  284. typedef DragInputUPP DragInputProc;
  285.  
  286. typedef pascal OSErr (*DragDrawingProcPtr)(DragRegionMessage message, RgnHandle showRegion, Point showOrigin, RgnHandle hideRegion, Point hideOrigin, void *dragDrawingRefCon, DragReference theDragRef);
  287.  
  288. #if GENERATINGCFM
  289. typedef UniversalProcPtr DragDrawingUPP;
  290. #else
  291. typedef DragDrawingProcPtr DragDrawingUPP;
  292. #endif
  293.  
  294. enum {
  295.     uppDragDrawingProcInfo = kPascalStackBased
  296.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  297.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DragRegionMessage)))
  298.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(RgnHandle)))
  299.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(Point)))
  300.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(RgnHandle)))
  301.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(Point)))
  302.          | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(void*)))
  303.          | STACK_ROUTINE_PARAMETER(7, SIZE_CODE(sizeof(DragReference)))
  304. };
  305.  
  306. #if GENERATINGCFM
  307. #define NewDragDrawingProc(userRoutine)        \
  308.         (DragDrawingUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragDrawingProcInfo, GetCurrentArchitecture())
  309. #else
  310. #define NewDragDrawingProc(userRoutine)        \
  311.         ((DragDrawingUPP) (userRoutine))
  312. #endif
  313.  
  314. #if GENERATINGCFM
  315. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        \
  316.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppDragDrawingProcInfo, (message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  317. #else
  318. #define CallDragDrawingProc(userRoutine, message, showRegion, showOrigin, hideRegion, hideOrigin, dragDrawingRefCon, theDragRef)        \
  319.         (*(userRoutine))((message), (showRegion), (showOrigin), (hideRegion), (hideOrigin), (dragDrawingRefCon), (theDragRef))
  320. #endif
  321.  
  322. typedef DragDrawingUPP DragDrawingProc;
  323.  
  324. /* Drag Manager Routines */
  325. /* Installing and Removing Drag Handlers */
  326. extern pascal OSErr InstallTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow, void *handlerRefCon)
  327.  TWOWORDINLINE(0x7001, 0xABED);
  328. extern pascal OSErr InstallReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow, void *handlerRefCon)
  329.  TWOWORDINLINE(0x7002, 0xABED);
  330. extern pascal OSErr RemoveTrackingHandler(DragTrackingHandler trackingHandler, WindowPtr theWindow)
  331.  TWOWORDINLINE(0x7003, 0xABED);
  332. extern pascal OSErr RemoveReceiveHandler(DragReceiveHandler receiveHandler, WindowPtr theWindow)
  333.  TWOWORDINLINE(0x7004, 0xABED);
  334. /* Creating and Disposing Drag References */
  335. extern pascal OSErr NewDrag(DragReference *theDragRef)
  336.  TWOWORDINLINE(0x7005, 0xABED);
  337. extern pascal OSErr DisposeDrag(DragReference theDragRef)
  338.  TWOWORDINLINE(0x7006, 0xABED);
  339. /* Adding Drag Item Flavors */
  340. extern pascal OSErr AddDragItemFlavor(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size dataSize, FlavorFlags theFlags)
  341.  TWOWORDINLINE(0x7007, 0xABED);
  342. extern pascal OSErr SetDragItemFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, const void *dataPtr, Size dataSize, unsigned long dataOffset)
  343.  TWOWORDINLINE(0x7009, 0xABED);
  344. /* Providing Drag Callback Procedures */
  345. extern pascal OSErr SetDragSendProc(DragReference theDragRef, DragSendDataProc sendProc, void *dragSendRefCon)
  346.  TWOWORDINLINE(0x700A, 0xABED);
  347. extern pascal OSErr SetDragInputProc(DragReference theDragRef, DragInputProc inputProc, void *dragInputRefCon)
  348.  TWOWORDINLINE(0x700B, 0xABED);
  349. extern pascal OSErr SetDragDrawingProc(DragReference theDragRef, DragDrawingProc drawingProc, void *dragDrawingRefCon)
  350.  TWOWORDINLINE(0x700C, 0xABED);
  351. extern pascal OSErr TrackDrag(DragReference theDragRef, const EventRecord *theEvent, RgnHandle theRegion)
  352.  TWOWORDINLINE(0x700D, 0xABED);
  353. /* Getting Drag Item Information */
  354. extern pascal OSErr CountDragItems(DragReference theDragRef, unsigned short *numItems)
  355.  TWOWORDINLINE(0x700E, 0xABED);
  356. extern pascal OSErr GetDragItemReferenceNumber(DragReference theDragRef, unsigned short index, ItemReference *theItemRef)
  357.  TWOWORDINLINE(0x700F, 0xABED);
  358. extern pascal OSErr CountDragItemFlavors(DragReference theDragRef, ItemReference theItemRef, unsigned short *numFlavors)
  359.  TWOWORDINLINE(0x7010, 0xABED);
  360. extern pascal OSErr GetFlavorType(DragReference theDragRef, ItemReference theItemRef, unsigned short index, FlavorType *theType)
  361.  TWOWORDINLINE(0x7011, 0xABED);
  362. extern pascal OSErr GetFlavorFlags(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, FlavorFlags *theFlags)
  363.  TWOWORDINLINE(0x7012, 0xABED);
  364. extern pascal OSErr GetFlavorDataSize(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, Size *dataSize)
  365.  TWOWORDINLINE(0x7013, 0xABED);
  366. extern pascal OSErr GetFlavorData(DragReference theDragRef, ItemReference theItemRef, FlavorType theType, void *dataPtr, Size *dataSize, unsigned long dataOffset)
  367.  TWOWORDINLINE(0x7014, 0xABED);
  368. extern pascal OSErr GetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, Rect *itemBounds)
  369.  TWOWORDINLINE(0x7015, 0xABED);
  370. extern pascal OSErr SetDragItemBounds(DragReference theDragRef, ItemReference theItemRef, const Rect *itemBounds)
  371.  TWOWORDINLINE(0x7016, 0xABED);
  372. extern pascal OSErr GetDropLocation(DragReference theDragRef, AEDesc *dropLocation)
  373.  TWOWORDINLINE(0x7017, 0xABED);
  374. extern pascal OSErr SetDropLocation(DragReference theDragRef, const AEDesc *dropLocation)
  375.  TWOWORDINLINE(0x7018, 0xABED);
  376. /* Getting Information About a Drag */
  377. extern pascal OSErr GetDragAttributes(DragReference theDragRef, DragAttributes *flags)
  378.  TWOWORDINLINE(0x7019, 0xABED);
  379. extern pascal OSErr GetDragMouse(DragReference theDragRef, Point *mouse, Point *pinnedMouse)
  380.  TWOWORDINLINE(0x701A, 0xABED);
  381. extern pascal OSErr SetDragMouse(DragReference theDragRef, Point pinnedMouse)
  382.  TWOWORDINLINE(0x701B, 0xABED);
  383. extern pascal OSErr GetDragOrigin(DragReference theDragRef, Point *initialMouse)
  384.  TWOWORDINLINE(0x701C, 0xABED);
  385. extern pascal OSErr GetDragModifiers(DragReference theDragRef, short *modifiers, short *mouseDownModifiers, short *mouseUpModifiers)
  386.  TWOWORDINLINE(0x701D, 0xABED);
  387. /* Drag Highlighting */
  388. extern pascal OSErr ShowDragHilite(DragReference theDragRef, RgnHandle hiliteFrame, Boolean inside)
  389.  TWOWORDINLINE(0x701E, 0xABED);
  390. extern pascal OSErr HideDragHilite(DragReference theDragRef)
  391.  TWOWORDINLINE(0x701F, 0xABED);
  392. extern pascal OSErr DragPreScroll(DragReference theDragRef, short dH, short dV)
  393.  TWOWORDINLINE(0x7020, 0xABED);
  394. extern pascal OSErr DragPostScroll(DragReference theDragRef)
  395.  TWOWORDINLINE(0x7021, 0xABED);
  396. extern pascal OSErr UpdateDragHilite(DragReference theDragRef, RgnHandle updateRgn)
  397.  TWOWORDINLINE(0x7022, 0xABED);
  398. /* Drag Manager Utilities */
  399. extern pascal Boolean WaitMouseMoved(Point initialMouse)
  400.  TWOWORDINLINE(0x7023, 0xABED);
  401. extern pascal OSErr ZoomRects(const Rect *fromRect, const Rect *toRect, short zoomSteps, ZoomAcceleration acceleration)
  402.  TWOWORDINLINE(0x7024, 0xABED);
  403. extern pascal OSErr ZoomRegion(RgnHandle region, Point zoomDistance, short zoomSteps, ZoomAcceleration acceleration)
  404.  TWOWORDINLINE(0x7025, 0xABED);
  405.  
  406. #if PRAGMA_IMPORT_SUPPORTED
  407. #pragma import off
  408. #endif
  409.  
  410. #if PRAGMA_ALIGN_SUPPORTED
  411. #pragma options align=reset
  412. #endif
  413.  
  414. #ifdef __cplusplus
  415. }
  416. #endif
  417.  
  418. #endif /* __DRAG__ */
  419.